home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / x2ftp / msdos / libs / knowhow4 / slang.h < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-02  |  4.8 KB  |  133 lines
  1. #ifndef __BASIC_H_
  2. #define __BASIC_H_
  3.  
  4. #include <stdlib.h>
  5. #include <stdio.h>
  6. #include <math.h>
  7. #include <ctype.h>
  8.  
  9. #include "slangtab.h"
  10. #include "var_tab.h"
  11.  
  12. #define NUM_LAB   100     // Number of labels
  13. #define LAB_LEN   10      // Length of label name
  14. #define FOR_NEST  25      // Number of nested FOR cycles
  15. #define SUB_NEST  25      // Number of nested SUBROUTINES calls
  16. #define PROG_SIZE 10000   // Maximum program size (or use multifile projects)
  17. #define LINE_LEN 160      // Program line len (LINE - CR - LINE ...)
  18.  
  19. struct for_stack
  20.     {
  21.     char name[10];  // Counter - cycle variable name
  22.     double endval;  // Cycle end value
  23.     char* entrance; // Point in the program string
  24.     };
  25.  
  26. struct play_stack
  27.     {
  28.     char* prog;                            // Name of file
  29.     int shift;                             // Offset in this file
  30.     play_stack(char* s, int i)
  31.         { prog = strdup(s); shift = i; }
  32.     ~play_stack() { delete prog; }
  33.     };
  34.  
  35. struct label               // Label : LABEL NAME and pointer to the place
  36.     {                      // in the program
  37.     char name[LAB_LEN];
  38.     char* p;
  39.     };
  40.  
  41. class Slang                     // The base interpreter class
  42.     {
  43.     public:
  44.     int error;                         // Number of the error
  45.     char* program;          // SLANG program (contents of current file)
  46.     char* substack[SUB_NEST];          // Subroutines stack
  47.     play_stack* playstack[SUB_NEST];   // External files player
  48.     for_stack fstack[FOR_NEST];        // FOR stack
  49.  
  50.     int variable_type;  // Type of current variable
  51.     char   token_type;  // Type of token obtained
  52.     char tok;           // Group of token obtained
  53.     char token[LINE_LEN]; // Token obtained
  54.     char* theName;
  55.     int for_used;       // FOR stack top
  56.     int sub_used;       // Gosub stack top
  57.     int play_used;      // Play stack top
  58.  
  59.     char* prog;         // Program - from the current point to the end
  60.  
  61.     label* labels;      // Table of labels in current file
  62.  
  63.     VarTable* variables; // Table of variables
  64.  
  65.     public:
  66.     Slang();
  67.     ~Slang();
  68.  
  69.     void del();
  70.     void set_error(int err) { error = err; }
  71.     int get_argument(double* x);
  72.     int get_error() { return error; }
  73.     void set_program(char* p) { program = p; }
  74.     char* get_program() { return program; }
  75.     char* load_program(char*); // Remove old program and load new file
  76.     char* find_label(char*);   // Find label name in the table
  77.     char* sub_pop();           // Get subroutine parameters from stack
  78.     void sub_push(char*);      // Push Gosub parameters to stack
  79.     for_stack for_pop();       // Get FOR parameters from stack
  80.     void for_push(for_stack);  // Push FOR parameters to stack
  81.     void playpush(char*, int); // Push external file parameters to stack
  82.     play_stack* playpop();     // Get external file parameters from stack
  83.     void print();              // General output function
  84.     void input();              // General input function
  85.     void scan_labels();        // Scan file and fill labels
  86.     void find_eol();           // Scip line
  87.     void find_return();        // Search for RETURN (\r\n)
  88.     void slang_goto();         // GOTO operator
  89.     void slang_if();           // IF operator
  90.     void slang_for();          // FOR operator
  91.     void next();               // NEXT operator
  92.     void gosub();              // Pass control to the subroutine
  93.     void sub_return();         // Return from subroutine
  94.     void label_init();         // Init labels
  95.     int get_next_label(char*); // Get next label
  96.     int reassign_arguments();  // We use assign_ and reassign_arguments
  97.     int assign_arguments();    // with subroutines calls to pass args.
  98.     void release_var(char* );  // Remove variable from table
  99.     void assigment();          // Assign value to variable
  100.     void basic(char*);         // Executes program pointed by char*
  101.     void play();               // Play external file
  102.     virtual void interprete(); // basic() call it in cycle
  103.     void get_label();
  104.  
  105.     void math(double* result);  // sin, cos...
  106.     void pause();               // See "C" delay() function
  107.  
  108.     char* get_exp(double*), *level2(double*); // Recursive analyser
  109.     char* level3(double*), *level4(double*);  // User could modify
  110.     char* level5(double*), *level6(double*);  // the "primitive" function
  111.     char* level7(double*);                    // and add COMMAND group
  112.     char* primitive(double*);                 // user-defined functions
  113.     void arith(char, double*, double*);
  114.     void unary(char, double*);
  115.  
  116.     virtual void serror(int);  // Error processor
  117.     virtual void error_report(char* text); // Overload for your own print
  118.  
  119.     void putback();            // Put token back
  120.     int get_token();           // Get token from prog
  121.     int iswhite(char);         // Recognize symbols to skip
  122.     int isdelim(char);         // Recognize delimiters (),:;" and so on
  123.  
  124.     virtual void terminate();  // User-defined terminator (ESC and so on)
  125.     };
  126.  
  127. #endif __BASIC_H_
  128.  
  129.  
  130.  
  131.  
  132.  
  133.